package com.yzqp.generator.util.resolve;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import com.sun.corba.se.impl.resolver.SplitLocalResolverImpl;
import com.yzqp.generator.util.ParamMap;
import lombok.Data;

import java.util.ArrayList;
import java.util.List;

/**
 * 4. 非终结符表达式
 * 　　每个非终结符表达式都代表了一个文法规则，并且每个文法规则都只关心自己周边的文法规则的结果，因此这就产生了每个非终结符表达式调用自己周边的非终结符表达式，然后最终、最小的文法规则就是终结符表达式。
 * 子类有： if表达式 for表达式
 */
@Data
public class ForFunctionNonterminalResolveExpression extends NonterminalResolveExpression {

    public ForFunctionNonterminalResolveExpression(String expressionString, ParamMap paramMap) {
        super(expressionString, paramMap);
    }

    @Override
    public String interpreter() {

        // 没有处理的字符串
        String expressionString = this.expressionString;

        // 解析字符串
        // 查看是否有for
        if (expressionString.indexOf("#.{startfor") > -1) {
            // 寻找 for函数的开始和结束的下标
            // 开始的下标 即 #{for 的#的下标
            int startIndex = expressionString.indexOf("#.{startfor");
            // 结束的下标 即 #{forend} 的}的下标
            int endIndex = ResolveContext.getEndFunctionIndex(startIndex, expressionString);

            // 根据for循环的开始结束下标 切割出 已经解析的字符串 还没有解析的字符串 要解析的字符串
            String inDealString = expressionString.substring(startIndex, endIndex + 1);


            /**
             * before
             * #{for packageList}
             * import ${item}
             * #{endfor}
             * after
             */
            // 解析for循环
            // 解析循环列表
            int listStartIndex = inDealString.indexOf("#.{startfor");
            listStartIndex = listStartIndex + 11;
            int listEndIndex = inDealString.indexOf(".}");
            listEndIndex = listEndIndex - 1;
            String listKey = inDealString.substring(listStartIndex, listEndIndex + 1);
            listKey = listKey.trim();
            // 解析需要循环的字符串
            int loopStartIndex = inDealString.indexOf(".}");
            loopStartIndex = loopStartIndex + 2;
            int loopEndIndex = inDealString.indexOf("#.{forend .}") - 1;
            String loopString = inDealString.substring(loopStartIndex, loopEndIndex + 1);
            // 重新修改开始结束标志 函数内容要包括 之前的换行符
            char[] cs = loopString.toCharArray();
            int len = -1;
            for (int i = loopString.length() - 1; i >= 0; i--) {
                char c = cs[i];
                if (c == '\n') {
                    len = i - 1;
                    break;
                }
            }
            loopString = new String(cs, 0, len);

            // 循环解析
            // 获取集合
            String mapString = paramMap.get(listKey);
            ArrayList<Object> list = JSON.parseObject(mapString, new TypeReference<ArrayList<Object>>() {
            });
            String forString = "";
            for (int i = 0; i < list.size(); i++) {
                // 克隆paramMap对象
                paramMap = paramMap.cloneObject();
                // 设置单项
                paramMap.put("item", list.get(i));

                // 递归处理
                // for函数内的内容再次解析
                List<ResolveExpression> forInnerExpressionList = ResolveContext.resolve(loopString, paramMap.cloneObject());

                for (ResolveExpression resolveExpression : forInnerExpressionList) {
                    resolveExpressionList.add(resolveExpression);
                }
            }


        }


        String value = "";
        for (ResolveExpression resolveExpression : resolveExpressionList) {
            value = value + resolveExpression.interpreter();
        }
        return value;
    }
}
